home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.004 / xemacs-1 / xemacs-19.13 / src / lstream.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-13  |  7.9 KB  |  191 lines
  1. /* Generic stream implementation -- header file.
  2.    Copyright (C) 1995 Amdahl Corporation.
  3.  
  4. This file is part of XEmacs.
  5.  
  6. XEmacs is free software; you can redistribute it and/or modify it
  7. under the terms of the GNU General Public License as published by the
  8. Free Software Foundation; either version 2, or (at your option) any
  9. later version.
  10.  
  11. XEmacs is distributed in the hope that it will be useful, but WITHOUT
  12. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14. for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with XEmacs; see the file COPYING.  If not, write to the Free
  18. Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /* Synched up with: Not in FSF. */
  21.  
  22. /* Written by Ben Wing. */
  23.  
  24. DECLARE_LRECORD (lstream, struct lstream);
  25. #define XLSTREAM(x) XRECORD (x, lstream, struct lstream)
  26. #define XSETLSTREAM(x, p) XSETRECORD (x, p, lstream)
  27. #define LSTREAMP(x) RECORDP (x, lstream)
  28. #define CHECK_LSTREAM(x, i) CHECK_RECORD (x, lstream)
  29.  
  30. extern Lisp_Object Fstreamp (Lisp_Object obj);
  31.  
  32. #ifndef EOF
  33. #define EOF (-1)
  34. #endif
  35.  
  36. typedef enum lstream_buffering
  37. {
  38.   /* No buffering. */
  39.   LSTREAM_UNBUFFERED,
  40.   /* Buffer until a '\n' character is reached. */
  41.   LSTREAM_LINE_BUFFERED,
  42.   /* Buffer in standard-size (i.e. 512-byte) blocks. */
  43.   LSTREAM_BLOCK_BUFFERED,
  44.   /* Buffer in blocks of a specified size. */
  45.   LSTREAM_BLOCKN_BUFFERED,
  46.   /* Buffer until the stream is closed (only applies to write-only
  47.      streams).  Only one call to the stream writer will be made,
  48.      and that is when the stream is closed. */
  49.   LSTREAM_UNLIMITED
  50. } Lstream_buffering;
  51.  
  52. /* Methods defining how this stream works.  Some may be undefined. */
  53.    
  54. typedef struct lstream_implementation
  55. {
  56.   char *name;
  57.   /* Read some data from the stream's end and store it into DATA, which
  58.      can hold SIZE bytes.  Return the number of bytes read.  0 means
  59.      EOF reached.  This function can be NULL if the stream is output-
  60.      only. */
  61.   int (*reader) (Lstream *stream, unsigned char *data, int size);
  62.   /* Send some data to the stream's end.  Data to be sent is in
  63.      DATA and is SIZE bytes.  Return the number of bytes sent.  0
  64.      means cannot store any more data (e.g. fixed block of memory),
  65.      and the data will be discarded.  If fewer bytes are sent than
  66.      provided, the remaining bytes will be sent the next time around.
  67.      This function can be NULL if the stream is input-only. */
  68.   int (*writer) (Lstream *stream, CONST unsigned char *data, int size);
  69.   /* Rewind the stream.  If this is NULL, the stream is not seekable. */
  70.   int (*rewinder) (Lstream *stream);
  71.   /* Perform any additional operations necessary to close this
  72.      stream down.  May be NULL.  This function is called when
  73.      Lstream_close() is called or when the stream is garbage-
  74.      collected.  When this function is called, all pending data
  75.      in the stream will already have been written out. */
  76.   int (*closer) (Lstream *stream);
  77.   /* Mark this object for garbage collection.  Same semantics as
  78.      a standard Lisp_Object marker.  This function can be NULL. */
  79.   Lisp_Object (*marker) (Lisp_Object lstream, void (*markfun) (Lisp_Object));
  80.   int size; /* Number of additional bytes to be allocated with this
  81.            stream.  Access this data using Lstream_data(). */
  82. } Lstream_implementation; 
  83.  
  84. #define DEFINE_LSTREAM_IMPLEMENTATION(name,c_name,richman,poorman,beggarman,thief,and_somebody_else,size)                        \
  85.  CONST_IF_NOT_DEBUG Lstream_implementation c_name[1] =            \
  86.    { { (name), (richman), (poorman), (beggarman), (thief),        \
  87.        (and_somebody_else), (size) } }
  88.  
  89. struct lstream
  90. {
  91.   struct lcrecord_header header;
  92.   CONST Lstream_implementation *imp; /* methods for this stream */
  93.   Lstream_buffering buffering; /* type of buffering in use */
  94.   int buffering_size; /* number of bytes buffered */
  95.  
  96.   unsigned char *in_buffer; /* holds characters read from stream end */
  97.   int in_buffer_size; /* allocated size of buffer */
  98.   int in_buffer_current; /* number of characters in buffer */
  99.   int in_buffer_ind; /* pointer to next character to take from buffer */
  100.  
  101.   unsigned char *out_buffer; /* holds characters to write to stream end */
  102.   int out_buffer_size; /* allocated size of buffer */
  103.   int out_buffer_ind; /* pointer to next buffer spot to write a character */
  104.  
  105.   unsigned char *unget_buffer; /* holds characters pushed back onto input */
  106.   int unget_buffer_size; /* allocated size of buffer */
  107.   int unget_buffer_start; /* read characters from here */
  108.   int unget_buffer_end; /* write characters to here */
  109.  
  110.   int byte_count;
  111.   long is_open;  /* Align pointer for 64 bit machines (kny) */
  112.   char data[1];
  113. };
  114.  
  115. extern Lstream *Lstream_new (CONST Lstream_implementation *imp);
  116. extern void Lstream_reopen (Lstream *lstr);
  117. extern void Lstream_set_buffering (Lstream *lstr, Lstream_buffering buffering,
  118.                    int buffering_size);
  119. extern int Lstream_flush (Lstream *lstr);
  120. extern int Lstream_flush_out (Lstream *lstr);
  121. extern int Lstream_fputc (Lstream *stream, int c);
  122. extern int Lstream_fgetc (Lstream *stream);
  123. extern void Lstream_fungetc (Lstream *stream, int c);
  124. extern int Lstream_read (Lstream *stream, void *data, int size);
  125. extern int Lstream_write (Lstream *stream, CONST void *data, int size);
  126. extern void Lstream_unread (Lstream *stream, void *data, int size);
  127. extern int Lstream_rewind (Lstream *stream);
  128. extern int Lstream_close (Lstream *stream);
  129.  
  130. /* Call the function equivalent if the out buffer is full.  Otherwise,
  131.    add to the end of the out buffer and, if line buffering is called for
  132.    and the character marks the end of a line, write out the buffer. */
  133.    
  134. #define Lstream_putc(stream, c)                     \
  135.   ((stream)->out_buffer_ind >= (stream)->out_buffer_size ?        \
  136.    Lstream_fputc (stream, c) :                        \
  137.    ((stream)->out_buffer[(stream)->out_buffer_ind++] =            \
  138.     (unsigned char) (c),                        \
  139.     (stream)->byte_count++,                        \
  140.     (stream)->buffering == LSTREAM_LINE_BUFFERED &&            \
  141.     (stream)->out_buffer[(stream)->out_buffer_ind - 1] == '\n' ?    \
  142.     Lstream_flush_out (stream) : 0))
  143.  
  144. /* Retrieve from unget buffer if there are any characters there;
  145.    else retrieve from in buffer if there's anything there;
  146.    else call the function equivalent */
  147. #define Lstream_getc(stream)                         \
  148.   ((stream)->unget_buffer_start < (stream)->unget_buffer_end ?        \
  149.    ((stream)->byte_count++,                        \
  150.     (stream)->unget_buffer[(stream)->unget_buffer_start++]) :        \
  151.    (stream)->in_buffer_ind < (stream)->in_buffer_current ?        \
  152.     ((stream)->byte_count++,                        \
  153.      (stream)->in_buffer[(stream)->in_buffer_ind++]) :            \
  154.     Lstream_fgetc (stream))
  155.  
  156. /* Add to the end if it won't overflow buffer; otherwise call the
  157.    function equivalent */
  158. #define Lstream_ungetc(stream, c)                    \
  159.   ((stream)->unget_buffer_end >= (stream)->unget_buffer_size ?        \
  160.    Lstream_fungetc (stream, c) :                    \
  161.    (void) ((stream)->byte_count--,                    \
  162.    ((stream)->unget_buffer[(stream)->unget_buffer_end++] =        \
  163.     (unsigned char) (c))))
  164.  
  165. #define Lstream_data(stream) ((void *) ((stream)->data))
  166. #define Lstream_byte_count(stream) ((stream)->byte_count)
  167.  
  168.  
  169.  
  170. /**************** stream implementations ****************/
  171.  
  172. #define LSTR_CLOSING 1
  173. #define LSTR_ALLOW_QUIT 2
  174. extern Lisp_Object make_stdio_stream (FILE *stream, int flags);
  175. extern Lisp_Object make_filedesc_stream (int filedesc, int flags);
  176. extern void filedesc_stream_set_pty_flushing (Lstream *stream,
  177.                           int pty_max_bytes,
  178.                           Bufbyte eof_char);
  179. extern Lisp_Object make_lisp_string_stream (Lisp_Object string,
  180.                         Bytecount offset,
  181.                         Bytecount len);
  182. extern Lisp_Object make_fixed_buffer_stream (unsigned char *buf,
  183.                          int size);
  184. extern unsigned char *fixed_buffer_stream_ptr (Lstream *stream);
  185. extern Lisp_Object make_resizing_buffer_stream (void);
  186. extern unsigned char *resizing_buffer_stream_ptr (Lstream *stream);
  187. #define LSTR_SELECTIVE 1
  188. #define LSTR_IGNORE_ACCESSIBLE 2
  189. extern Lisp_Object make_lisp_buffer_stream (struct buffer *buf, Bufpos pos,
  190.                         Bufpos length, int flags);
  191.